home *** CD-ROM | disk | FTP | other *** search
/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc B) / Acorn User China CD-ROM (UK) (Disc B).bin / STUTTGART / FROMUTS / UNIXLIB37B / src_c_termcap < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-29  |  13.8 KB  |  837 lines
  1. #ifdef __STDC__
  2. static char sccs_id[] = "@(#) termcap.c 5.6 "__DATE__" HJR";
  3. #else
  4. static char sccs_id[] = "@(#) termcap.c 5.6 25/2/92 HJR";
  5. #endif
  6.  
  7. /* termcap.c (c) Copyright 1989/1990/1991/1992 H.Rogers */
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12.  
  13. #ifdef __STDC__ /* implies ANSI C compilation */
  14. #include <stdlib.h>
  15. #else
  16. char *getenv();
  17. char *malloc();
  18. extern long strtol();
  19. #define const
  20. #endif
  21.  
  22. #include "termcap.h"
  23.  
  24. #ifdef ARCH
  25. #define T_BUILTIN    /* builtin termcap */
  26.  
  27. static char *t_bname = "acorn0";
  28. static unsigned char *t_btenv = (unsigned char *)
  29. "av|acorn0|Acorn VDU Driver Mode 0:"
  30.     ":li#32:co#80:am:cl=^L:bs:cm=^_%r%.%.:up=^K:ho=^^:bl=^G:bw:"
  31.     ":ce=^W^H^E^F\\200\\200\\200\\200\\200\\200:"
  32.     ":so=^W^Q^E\\200\\200\\200\\200\\200\\200\\200:"
  33.     ":se=^W^Q^E\\200\\200\\200\\200\\200\\200\\200:"
  34.     ":sb=^W^G^A^B\\200\\200\\200\\200\\200\\200:"
  35.     ":sf=^W^G^A^C\\200\\200\\200\\200\\200\\200:"
  36.     ":is=^C^F^D^O^V\\200:";
  37. #endif
  38.  
  39. #define T_IOCTL     /* use TIOCGWINSIZ to get LI,CO */
  40.  
  41. #ifdef T_IOCTL
  42. #include "termio.h"
  43.  
  44. #ifdef __STDC__
  45. extern int ioctl(int,int,void *);
  46. #else
  47. extern int ioctl();
  48. #endif
  49. #endif
  50.  
  51. /* #define T_TEST */    /* test main() */
  52. /* #define T_DEBUG */    /* debugging output to t_debug */
  53.  
  54. #define T_FILE "/etc/termcap"    /* the database file */
  55.  
  56. #ifdef __STDC__
  57. static int t_tgetnam(unsigned char **,unsigned char **);
  58. static int t_tgetln(FILE *,unsigned char *);
  59. static int t_tentcp(unsigned char *);
  60. static unsigned char *t_tgetid(char *);
  61. static unsigned char t_tcoord(int,unsigned int *);
  62. #else
  63. static int t_tgetnam();     /* extracts the next name from entry */
  64. static int t_tgetln();        /* reads line from termcap file */
  65. static int t_tentcp();        /* copies the termcap entry into bp */
  66. static unsigned char *t_tgetid();    /* returns a pointer to a capability */
  67. static unsigned char t_tcoord();    /* converts a coord to an output val */
  68. #endif /* __STDC__ */
  69.  
  70. #define MAXTC 64        /* max. tc indirections */
  71.  
  72. static char __PC,*__BC,*__UP;
  73.  
  74. static char *t_tbp;
  75. static unsigned char *t_tbpstart;
  76. static int t_recurs,t_tbpspace;
  77. static unsigned char *t_tenv;
  78.  
  79. #ifdef T_DEBUG
  80. static FILE *t_debug;
  81. #endif
  82.  
  83. /* tgetent() */
  84.  
  85. int tgetent(bp,name)
  86. char *bp,*name;
  87. {
  88. unsigned char *tenv,*tent,*tentbuf,tc;
  89. unsigned char *tp1,*tp2;
  90. char *fnam;
  91. FILE *tfile = 0;
  92. int nbyt,rval;
  93.  
  94. #ifdef T_DEBUG
  95. if (!t_recurs)
  96.   {
  97.   if (!(t_debug = fopen("t_debug","w"))) return(-1);
  98.   setvbuf(t_debug,(char *)0,_IONBF,BUFSIZ);
  99.   }
  100. #endif
  101.  
  102. if (!(t_tbp = bp)) return(-1);
  103.  
  104. if (!name)
  105. #ifdef T_BUILTIN
  106. #ifdef T_DEBUG
  107. fputs("tgetent(\"(null)\")\n",t_debug);
  108. #endif
  109.   name = t_bname;
  110. #else
  111.   return(-1);
  112. #endif
  113.  
  114. fnam = T_FILE;
  115.  
  116. if (!t_recurs) t_tbpspace = 1024;
  117.  
  118. if (!t_recurs)
  119.   {
  120.   char *t = getenv("TERM");
  121.  
  122.   if (!t) t = "";
  123.   if (!strcmp(name,t))
  124.     t_tenv = (unsigned char *)getenv("TERMCAP");
  125.   else
  126.     t_tenv = 0;
  127.   }
  128.  
  129. if (tenv = t_tenv)
  130.   {
  131.   if (!t_recurs && *tenv != '/')
  132.     {
  133. #ifdef T_BUILTIN
  134. builtin:
  135. #endif
  136.  
  137.     while (isspace(*tenv)) tenv++;
  138.     tp1 = tp2 = tenv;
  139.  
  140. #ifdef T_DEBUG
  141. fprintf(t_debug,"tgetent(\"%s\") < $TERMCAP\n",name);
  142. #endif
  143.  
  144.     while(t_tgetnam(&tp1,&tp2))
  145.       {
  146.       tc = *tp2; *tp2 = 0;
  147.  
  148. #ifdef T_DEBUG
  149. fprintf(t_debug,"t_tgetnam(): %s\n",(char *)tp1);
  150. #endif
  151.  
  152.       if (!strcmp((char *)tp1,name))
  153.     {
  154.     *tp2 = tc;
  155.  
  156. #ifdef T_DEBUG
  157. fputs("t_tgetnam() - MATCH -\n",t_debug);
  158. #endif
  159.  
  160.     if (strlen((char *)tenv) > t_tbpspace) return(-1);
  161.     return(t_tentcp(tenv) ? -1 : 1);
  162.     }
  163.       else
  164.     *tp2 = tc;
  165.       }
  166.     }
  167.   else if (*tenv == '/')
  168.     {
  169.  
  170. #ifdef T_DEBUG
  171. fprintf(t_debug,"tgetent(\"%s\") < %s\n",name,(char *)tenv);
  172. #endif
  173.  
  174.     fnam = (char *)tenv;
  175.     }
  176.   }
  177.  
  178. #ifdef T_DEBUG
  179. if (fnam != (char *)t_tenv)
  180.   fprintf(t_debug,"tgetent(\"%s\") < /etc/termcap\n",name);
  181. #endif
  182.  
  183. if (!(tfile = fopen(fnam,"r")))
  184. #ifdef T_BUILTIN
  185.   {
  186.   if (fnam != (char *)t_tenv && !strcmp(name,t_bname))
  187.     { tenv = t_btenv; goto builtin; }
  188.   else
  189.     return(-1);
  190.   }
  191. #else
  192.   return(-1);
  193. #endif
  194.  
  195. tent = tentbuf = (unsigned char *)malloc(1024);
  196.  
  197. while (nbyt = t_tgetln(tfile,tent))
  198.   {
  199.   if (*tent != '#')
  200.     {
  201.     while (isspace(*tent)) tent++;
  202.     tp1 = tp2 = tent;
  203.     while(t_tgetnam(&tp1,&tp2))
  204.       {
  205.       tc = *tp2; *tp2 = 0;
  206.  
  207. #ifdef T_DEBUG
  208. fprintf(t_debug,"t_tgetnam(): %s\n",(char *)tp1);
  209. #endif
  210.  
  211.       if (!strcmp((char *)tp1,name))
  212.     {
  213.     *tp2 = tc;
  214.  
  215. #ifdef T_DEBUG
  216. fprintf(t_debug,"t_tgetnam() - MATCH -\n");
  217. fprintf(t_debug,"t_tgetnam(): [%d (%d)] %s\n",nbyt,t_tbpspace,tent);
  218. #endif
  219.  
  220.     if (nbyt > t_tbpspace || nbyt < 0)
  221.       { free((char *)tentbuf); return(-1); }
  222.     if (tfile) { fclose(tfile); tfile = 0; }
  223.     rval = t_tentcp(tent);
  224.     free((char *)tentbuf);
  225.     return(rval ? -1 : 1);
  226.     }
  227.       else
  228.     *tp2 = tc;
  229.       }
  230.     }
  231.   }
  232.  
  233. if (tfile) { fclose(tfile); tfile = 0; }
  234.  
  235. free((char *)tentbuf);
  236.  
  237. return(0);
  238. }
  239.  
  240. /* t_tgetnam() */
  241.  
  242. static int t_tgetnam(t1,t2)
  243. unsigned char **t1,**t2;
  244. {
  245. register unsigned char *tp1 = *t1,*tp2 = *t2;
  246.  
  247. while ((*tp2 == '|') || isspace(*tp2)) tp2++;
  248. if (*tp2 == ':') return(0);
  249. tp1 = tp2;
  250. while ((*tp2 != '|') && (*tp2 != ':')) tp2++;
  251.  
  252. *t1 = tp1; *t2 = tp2;
  253. return(-1);
  254. }
  255.  
  256. /* t_tentcp() */
  257.  
  258. static int t_tentcp(s)
  259. unsigned char *s;
  260. {
  261. register unsigned char *s1,*s2,*sp;
  262. char *t_tbp_;
  263. char *tcnam,*tcn;
  264.  
  265. #ifdef T_DEBUG
  266. fputs("t_tentcp()\n",t_debug);
  267. #endif
  268.  
  269. tcnam = (char *)malloc(256);
  270.  
  271. s1 = (unsigned char *)t_tbp;
  272. s2 = s;
  273.  
  274. while (*s2)
  275.   {
  276.   if (*s2 == ':')  /* strips out empty capabilities :: */
  277.     {
  278.     sp = s2 + 1;
  279.     while (isspace(*sp)) sp++;
  280.     if (*sp == ':') s2 = sp;
  281.     }
  282.   *s1++ = *s2++;
  283.   }
  284.  
  285. *s1 = 0;
  286.  
  287. if (!t_recurs)
  288.   {
  289.   sp = (unsigned char *)t_tbp;
  290.   while (*sp++ != ':');
  291.   t_tbpstart = sp;
  292.   }
  293.  
  294. if (sp = t_tgetid("tc"))
  295.   {
  296.  
  297. #ifdef T_DEBUG
  298. fprintf(t_debug,"tgetent()# %d\n",t_recurs);
  299. #endif
  300.  
  301.   if (++t_recurs > (MAXTC - 1))
  302.     { free(tcnam); return(-1); }
  303.   t_tbp_ = t_tbp;
  304.  
  305.   tcn = tcnam;
  306.   s1 = sp = sp-2;
  307.   t_tbpspace -= (int)(s1 - (unsigned char *)t_tbp);
  308.   if (tgetent((char *)s1,tgetstr("tc",&tcn)) < 1)
  309.     { free(tcnam); return(-1); }
  310.  
  311.   while (*sp++ != ':');
  312.   while (*s1++ = *sp++);
  313.  
  314.   t_tbp = t_tbp_;
  315.   t_recurs--;
  316.   }
  317.  
  318. #ifdef T_DEBUG
  319. fprintf(t_debug,"tgetent(): %s\n",t_tbp);
  320. #endif
  321.  
  322. if (!t_recurs)
  323.   {
  324.   __PC = 0; __BC = "\b"; __UP = "\v";
  325.   }
  326.  
  327. free(tcnam);
  328.  
  329. return(0);
  330. }
  331.  
  332. /* t_tgetln() */
  333.  
  334. static int t_tgetln(tfile,buf)
  335. FILE *tfile;
  336. register unsigned char *buf;
  337. {
  338. register unsigned char *bufp;
  339. register int nbyt;
  340.  
  341. bufp = buf;
  342. nbyt = 0;
  343.  
  344. while (-1)
  345.   {
  346.   if (!fgets((char *)bufp,t_tbpspace - nbyt,tfile)) return(nbyt);
  347.   while (*bufp++); bufp--;
  348.   if (*--bufp != '\n') ++bufp;
  349.   nbyt += (bufp - buf);
  350.   if (!nbyt) continue;
  351.   if (*--bufp != '\\') { *++bufp = 0; return(nbyt); }
  352.   buf = bufp; nbyt--;
  353.   }
  354. }
  355.  
  356. /* t_tgetid() */
  357.  
  358. static unsigned char *t_tgetid(id)
  359. register char *id;
  360. {
  361. register unsigned char *bptr;
  362. int found;
  363.  
  364. if ((!id) || (!t_tbpstart)) return(0);
  365.  
  366. bptr = t_tbpstart;
  367. while (*bptr)
  368.   {
  369.   found = (((unsigned char)*id++ == *bptr++) ? \
  370.     ((unsigned char)*id == *bptr) : 0);
  371.   bptr++; id--;
  372.   if (found)
  373.     {
  374.     if (*bptr == '@') return(0);
  375.     else return(bptr);
  376.     }
  377.   while ((*bptr != ':') && (*bptr != 0)) bptr++;
  378.   if (*bptr == ':') bptr++;
  379.   }
  380. return(0);
  381. }
  382.  
  383. /* tgetnum() */
  384.  
  385. int tgetnum(id)
  386. char *id;
  387. {
  388. register unsigned char *eptr;
  389. int rval;
  390.  
  391. #ifdef TIOCGWINSZ
  392. if (rval = (!strncmp(id,"li",2) ? 1 : (!strncmp(id,"co",2) ? -1 : 0)))
  393.   {
  394.   struct winsize w[1];
  395.  
  396.   ioctl(2,TIOCGWINSZ,w);
  397.   return((rval > 0) ? w->ws_row : w->ws_col);
  398.   }
  399. #endif
  400.  
  401. if (!(eptr = t_tgetid(id))) return(-1);
  402.  
  403. if (*eptr++ != '#') return(0);
  404. rval = atoi((const char *)eptr);
  405.  
  406. #ifdef T_DEBUG
  407. fprintf(t_debug,"tgetnum(\"%s\"): %d\n",id,rval);
  408. #endif
  409.  
  410. return(rval);
  411. }
  412.  
  413. /* tgetflag() */
  414.  
  415. int tgetflag(id)
  416. char *id;
  417. {
  418. register unsigned char *idp;
  419.  
  420. #ifdef T_DEBUG
  421. int rval;
  422.  
  423. idp = t_tgetid(id);
  424. rval = (idp ? ((*idp != '@') ? 1 : 0) : 0);
  425. fprintf(t_debug,"tgetflag(\"%s\"): %d\n",id,rval);
  426. return(rval);
  427. #else
  428. idp = t_tgetid(id);
  429. return(idp ? ((*idp != '@') ? 1 : 0) : 0);
  430. #endif
  431. }
  432.  
  433. /* tgetstr() */
  434.  
  435. char *tgetstr(id,area)
  436. char *id,**area;
  437. {
  438. register unsigned char *eptr,*aptr;
  439. unsigned char obuf[4];
  440. char *rval;
  441.  
  442. #ifdef T_DEBUG
  443. fprintf(t_debug,"tgetstr(\"%s\")\n",id);
  444. #endif
  445.  
  446. if (!(area ? *area : 0))
  447.   {
  448.   rval = 0;
  449.   goto tgetstr_ret;
  450.   }
  451.  
  452. aptr = (unsigned char *)*area;
  453. if (!(eptr = t_tgetid(id))) return(0);
  454. if (*eptr++ != '=')
  455.   {
  456.   *aptr = 0;
  457.   return(0);
  458.   }
  459.  
  460. if ((*eptr >= '0') && (*eptr <= '9'))
  461.   {
  462.   while ((*eptr >= '0') && (*eptr <= '9')) *aptr++ = *eptr++;
  463.   if (*eptr == '*') *aptr++ = *eptr++;
  464.   }
  465.  
  466. obuf[3] = 0;
  467. while ((*eptr != ':') && (*eptr != 0))
  468.   {
  469.   switch (*eptr)
  470.     {
  471.     case '\\':
  472.       switch (*++eptr)
  473.     {
  474.     case 'E':
  475.       *aptr = 0x1b;
  476.       break;
  477.     case 'n':
  478.       *aptr = 0x0a;
  479.       break;
  480.     case 'r':
  481.       *aptr = 0x0d;
  482.       break;
  483.     case 't':
  484.       *aptr = 0x09;
  485.       break;
  486.     case 'b':
  487.       *aptr = 0x08;
  488.       break;
  489.     case 'f':
  490.       *aptr = 0x0c;
  491.       break;
  492.     case '0':
  493.     case '1':
  494.     case '2':
  495.     case '3':
  496.       obuf[0] = *eptr++;
  497.       obuf[1] = *eptr++;
  498.       obuf[2] = *eptr;
  499.       *aptr = (char)(strtol((const char *)obuf,0,8) & 0xff);
  500.       break;
  501.     default:
  502.       *aptr = *eptr;
  503.     }
  504.       break;
  505.     case '^':
  506.       *aptr = ((*++eptr) & 0x1f);
  507.       break;
  508.     default:
  509.       *aptr = *eptr;
  510.       break;
  511.     }
  512.   eptr++; aptr++;
  513.   }
  514.  
  515. *aptr++ = 0;
  516. rval = *area;
  517. *area = (char *)aptr;
  518.  
  519. tgetstr_ret:
  520.  
  521. #ifdef T_DEBUG
  522. fprintf(t_debug,"tgetstr(\"%s\"): %s\n",id,rval);
  523. #endif
  524.  
  525. if (rval)
  526.   {
  527.   if (id[1] == 'c')
  528.     {
  529.     if (id[0] == 'b')
  530.       __BC = rval;
  531.     else if (id[0] == 'p')
  532.       __PC = *rval & 0x7f;
  533.     }
  534.   else if (id[0] == 'u' && id[1] == 'p')
  535.     __UP = rval;
  536.   else if (id[0] == 'l' && id[1] == 'e')    /* terminfo compatibility */
  537.     __BC = rval;
  538.   }
  539.  
  540. return(rval);
  541. }
  542.  
  543. static int tg_aoff,tg_coff,tg_clev;
  544.  
  545. #define TG_revxy    0001
  546. #define TG_incxy    0002
  547. #define TG_eorxy    0004
  548. #define TG_bcdxy    0010
  549. #define TG_revcod    0020
  550. #define TG_bc        0040
  551. #define TG_up        0100
  552. #define TG_chkout    0200
  553.  
  554. /* tgoto() */
  555.  
  556. char *tgoto(cm,destcol,destline)
  557. char *cm;
  558. int destcol,destline;
  559. {
  560. static char rstr[256];
  561. register char *cmp,*rstrp,*cp;
  562. unsigned int f;
  563.  
  564. #define TC(f) (((f) & TG_revxy) ? destcol : destline)
  565.  
  566. #ifdef T_DEBUG
  567. fprintf(t_debug,"tgoto(\"%s\",%d,%d): ",cm,destcol,destline);
  568.  
  569. if (!cm) { putc('\n',t_debug); return(0); }
  570. #else
  571. if (!cm) return(0);
  572. #endif
  573.  
  574. tg_aoff = tg_coff = tg_clev = 0; f = 0;
  575.  
  576. cmp = cm;
  577. rstrp = rstr;
  578. while (*cmp)
  579.   {
  580.   if (*cmp == '%')
  581.     {
  582.     register int d;
  583.     register char *e;
  584.  
  585.     cmp++;
  586.     switch (*cmp++)
  587.       {
  588.       case 'r':
  589.     f |= TG_revxy;
  590.     break;
  591.       case 'i':
  592.     f |= TG_incxy;
  593.     break;
  594.       case 'n':
  595.     f |= TG_eorxy;
  596.     break;
  597.       case 'B':
  598.     f |= TG_bcdxy;
  599.     break;
  600.       case 'D':
  601.     f |= TG_revcod;
  602.     break;
  603.       case '>':
  604.     tg_clev = *cmp++;
  605.     tg_coff = *cmp++;
  606.     break;
  607.       case '+':
  608.     tg_aoff = *cmp++;    /* fallthru */
  609.       case '.':
  610.     f |= TG_chkout;
  611.     *rstrp++ = t_tcoord(TC(f),&f);
  612.     break;
  613.       case 'd':
  614.     d = (int)t_tcoord(TC(f),&f);
  615.     e = rstrp + 1; if (d > 9) e++; if (d > 99) e++; rstrp = e;
  616.     *e = 0; do { *--e = (d % 10) + '0'; d /= 10; } while (d);
  617.     break;
  618.       case '2':
  619.     d = (int)t_tcoord(TC(f),&f);
  620.     *rstrp = ' '; if (d > 99) *++rstrp = ' '; e = rstrp = rstrp + 2;
  621.     *e = 0; do { *--e = (d % 10) + '0'; d /= 10; } while (d);
  622.     break;
  623.       case '3':
  624.     d = (int)t_tcoord(TC(f),&f);
  625.     *rstrp = ' '; *++rstrp = ' '; e = rstrp = rstrp + 2;
  626.     *e = 0; do { *--e = (d % 10) + '0'; d /= 10; } while (d);
  627.     break;
  628.       case '%':
  629.     *rstrp++ = '%';
  630.     break;
  631.       default:
  632.     rstrp = "OOPS";
  633.     goto tgoto_ret;
  634.     break;
  635.       }
  636.     }
  637.   else *rstrp++ = *cmp++;
  638.   }
  639.  
  640. if (f & TG_bc)
  641.   {
  642.   cp = __BC;
  643.   while (*rstrp = *cp) rstrp++,cp++;
  644.   }
  645. if (f & TG_up)
  646.   {
  647.   cp = __UP;
  648.   while (*rstrp = *cp) rstrp++,cp++;
  649.   }
  650.  
  651. *rstrp = 0;
  652.  
  653. rstrp = rstr;
  654.  
  655. tgoto_ret:
  656.  
  657. #ifdef T_DEBUG
  658. fprintf(t_debug,"%s\n",rstrp);
  659. #endif
  660.  
  661. return(rstrp);
  662. }
  663.  
  664. /* t_tcoord() */
  665.  
  666. static unsigned char t_tcoord(x,_f)
  667. register int x;
  668. unsigned int *_f;
  669. {
  670. register unsigned int f;
  671.  
  672. t_tccalc:
  673.  
  674. f = (*_f);
  675.  
  676. if (x > tg_clev) x += tg_coff;
  677. x += tg_aoff;
  678. if (f & TG_incxy) x++;
  679. if (f & TG_eorxy) x ^= 0140;
  680. if (f & TG_bcdxy) x = ((x/10)<<4) | (x%10);
  681. if (f & TG_revcod) x = (x - ((x & 15)<<1));
  682.  
  683. if (f & TG_chkout)
  684.   {
  685.   (*_f) &= (~TG_chkout);
  686.   if (!x || x == '\004' || x == '\n' || x == '\r')
  687.     {
  688.     if (f & TG_revxy)
  689.       (*_f) |= TG_bc;
  690.     else
  691.       (*_f) |= TG_up;
  692.     x++;
  693.     goto t_tccalc;
  694.     }
  695.   }
  696.  
  697. (*_f) ^= TG_revxy;
  698. tg_aoff = 0;
  699. return(x);
  700. }
  701.  
  702. /* tputs() */
  703.  
  704. int tputs(cp,affcnt,outc)
  705. register char *cp;
  706. int affcnt;
  707. #ifdef __STDC__
  708. int (*outc)(char);
  709. #else
  710. int (*outc)();
  711. #endif
  712. {
  713. register int i;
  714. char *cpp;
  715. int delay;
  716.  
  717. #ifdef T_DEBUG
  718. fprintf(t_debug,"tputs(\"%s\",%d)\n",cp,affcnt);
  719. #endif
  720.  
  721. if ((!cp) || (!outc)) return(0);
  722.  
  723. if (isdigit(*cp))
  724.   { delay = (int)strtol(cp,&cpp,0); cp = cpp; }
  725. else
  726. #ifdef T_DEBUG
  727.   { cpp = cp; delay = 0; }
  728. #else
  729.   delay = 0;
  730. #endif
  731.  
  732. i = *cp;
  733.  
  734. if (i == '.') while(isdigit(*++cp));
  735. if (i == '*') { delay *= affcnt; cp++; }
  736.  
  737. if (ospeed > 13)
  738.   delay <<= (ospeed - 13);
  739. else
  740.   delay >>= (13 - ospeed);
  741.  
  742. #ifdef T_DEBUG
  743. fprintf(t_debug,"tputs() (pad %d): %s\n",delay,cpp);
  744. #endif
  745.  
  746. while (i = *cp++) (*outc)(i & 0x7f);
  747.  
  748. if (ospeed) while (delay-- > 0) (*outc)(__PC);
  749.  
  750. return(0);
  751. }
  752.  
  753. #ifdef T_TEST
  754.  
  755. char PC,*BC,*UP;
  756.  
  757. #ifdef __STDC__
  758. static int out(char);
  759. static void dump(char *);
  760. #else
  761. static int out();
  762. static void dump();
  763. #endif
  764.  
  765. /* main() */
  766.  
  767. #ifdef __STDC__
  768. int main(void)
  769. #else
  770. int main()
  771. #endif
  772. {
  773. static char bp[1024],tbuf[512];
  774. char *tbufp,*cm;
  775. int rval,i;
  776.  
  777. if ((rval = tgetent(bp,getenv("TERM"))) < 1)
  778.   {
  779.   fprintf(stderr,"termcap: tgetent() returned %d\n",rval);
  780.   exit(1);
  781.   }
  782.  
  783. tbufp = tbuf;
  784.  
  785. if (tgetstr("pc",&tbufp)) PC = *tbuf;
  786.  
  787. if (!(BC = tgetstr("bc",&tbufp))) BC = "\b";
  788.  
  789. UP = tgetstr("up",&tbufp);
  790.  
  791. tputs(tgetstr("cl",&tbufp),1,out);
  792.  
  793. printf("tgetent(): %s\n",bp);
  794.  
  795. printf("tgetflag(\"cm\"): %d\n",tgetflag("cm"));
  796.  
  797. printf("tgetnum(\"li\"): %d\n",tgetnum("li"));
  798.  
  799. tbufp = tbuf;
  800.  
  801. printf("tgetstr(\"cm\"): ");
  802. dump(cm = tgetstr("cm",&tbufp));
  803.  
  804. for (i = 0; i < 10; i++)
  805.   {
  806.   tputs(tgoto(cm,i<<1,i+20),1,out);
  807.   printf("%d",i);
  808.   }
  809.  
  810. printf("\n");
  811. }
  812.  
  813. #ifdef __STDC__
  814. static int out(char c)
  815. #else
  816. static int out(c)
  817. char c;
  818. #endif
  819. {
  820. return(putc(c,stdout));
  821. }
  822.  
  823. static void dump(s)
  824. char *s;
  825. {
  826. if (!s) { printf("(null)\n"); return; }
  827. while (*s)
  828.   {
  829.   if ((*s < ' ') || (*s > '\176')) printf("\\%03o",(int)*s);
  830.   else putc(*s,stdout);
  831.   s++;
  832.   }
  833. putc('\n',stdout);
  834. }
  835.  
  836. #endif /* T_TEST */
  837.